import axios, { type AxiosRequestConfig, type AxiosResponse } from 'axios';
import type { AxiosInstance } from 'axios';
// 定义接口返回数据的通用结构
interface ApiResponse<T = any> {
  code?: number;
  data?: T;
  message?: string;
  success?: boolean;
}

// 定义一个请求类
class Request {
  // 定义一个私有变量instance，类型为AxiosInstance
  private instance: AxiosInstance;
  // 定义一个只读变量options，类型为AxiosRequestConfig
  private readonly options: AxiosRequestConfig;

  // 构造函数，接收一个可选的AxiosRequestConfig参数
  constructor(options: AxiosRequestConfig = {}) {
    // 将参数赋值给options
    this.options = options;
    // 使用axios.create方法创建一个axios实例，并将options传入
    this.instance = axios.create(this.options);

    // 设置拦截器
    this.setupInterceptors();
  }

  // 设置拦截器的方法
  private setupInterceptors() {
    // 请求拦截器
    this.instance.interceptors.request.use(
      // 请求拦截器的回调函数，接收一个config参数
      config => {
        // 可以在这里添加token等
        // 从localStorage中获取token
        const token = localStorage.getItem('token');
        // 如果token存在，则将token添加到config的headers中
        if (token) {
          config.headers.Authorization = `Bearer ${token}`;
        }
        // 返回config
        return config;
      },
      // 请求拦截器的错误处理函数
      error => {
        // 返回一个被拒绝的Promise
        return Promise.reject(error);
      }
    );

    // 响应拦截器
    this.instance.interceptors.response.use(
      // 响应拦截器的回调函数，接收一个response参数
      (response: AxiosResponse<ApiResponse>) => {
        // 处理响应数据
        // 如果响应数据的code不等于200，则返回一个被拒绝的Promise
        if (response.data.code !== 200) {
          return Promise.reject(response.data);
        }
        // 否则返回响应数据的data
        return response.data.data;
      },
      // 响应拦截器的错误处理函数
      error => {
        // 统一错误处理
        // 调用handleError方法处理错误
        return this.handleError(error);
      }
    );
  }

  // 错误处理的方法
  private handleError(error: any) {
    // 可以根据HTTP状态码或业务code进行不同的处理
    // 如果error中有response属性，则根据response的status进行不同的处理
    if (error.response) {
      switch (error.response.status) {
        case 401:
          // 跳转到登录页
          break;
        case 403:
          // 提示无权限
          break;
        case 500:
          // 服务器错误
          break;
        default:
          break;
      }
    }
    // 返回一个被拒绝的Promise
    return Promise.reject(error);
  }

  // 发送请求的方法
  public request<T = any>(config: AxiosRequestConfig): Promise<T> {
    // 调用axios实例的request方法发送请求，并返回一个Promise
    return this.instance.request(config);
  }

  // 发送get请求的方法
  public get<T = any>(
    url: string,
    params?: any,
    config?: AxiosRequestConfig
  ): Promise<T> {
    // 调用axios实例的get方法发送get请求，并返回一个Promise
    return this.instance.get(url, { params, ...config });
  }

  // 发送post请求的方法
  public post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T> {
    // 调用axios实例的post方法发送post请求，并返回一个Promise
    return this.instance.post(url, data, config);
  }

  // 发送put请求的方法
  public put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T> {
    // 调用axios实例的put方法发送put请求，并返回一个Promise
    return this.instance.put(url, data, config);
  }

  // 发送delete请求的方法
  public delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T> {
    // 调用axios实例的delete方法发送delete请求，并返回一个Promise
    return this.instance.delete(url, config);
  }
}

// 创建默认实例
const defaultRequest = new Request({
  baseURL: import.meta.env.VITE_API_BASE_URL, // 基础URL，可根据环境变量配置
  timeout: 1000 * 10, // 设置请求超时时间为10秒
  // 设置默认请求头
  headers: {
    'Content-Type': 'application/json',
  },
});

export default defaultRequest;
